package org.Yiran.timetale_re.item.tool.screwdriver;

import net.minecraft.client.gui.screens.Screen;
import net.minecraft.core.BlockPos;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.network.chat.Component;
import net.minecraft.world.InteractionResult;
import net.minecraft.world.item.Item;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.item.TooltipFlag;
import net.minecraft.world.item.context.UseOnContext;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.block.state.properties.IntegerProperty;
import org.Yiran.timetale_re.block.crystal.base.CrystalBaseBlock;
import org.Yiran.timetale_re.item.ItemsRegister;
import org.Yiran.timetale_re.item.tool.screwdriver.core.ScrewdriverItem;
import org.Yiran.timetale_re.item.tool.screwdriver.modules.IModule;
import org.Yiran.timetale_re.item.tool.screwdriver.modules.Modules;
import org.Yiran.timetale_re.item.tool.screwdriver.modules.container.ToolModuleContainer;
import org.Yiran.timetale_re.item.tool.screwdriver.modules.enmu.ModuleType;
import org.jetbrains.annotations.NotNull;

import javax.annotation.Nullable;
import java.util.List;
import java.util.Map;

/**
 * 创造等级起子
 * <p>
 * 该类实现了创造等级的起子工具。
 * 创造起子具有无限模块槽位，并预装所有最高级模块。
 * 继承自ScrewdriverItem基类。
 * </p>
 */
public class CreativeScrewdriverItem extends ScrewdriverItem {
    private static final int DEFAULT_CAPACITY = Integer.MAX_VALUE;
    private static final int DEFAULT_TRANSFER = 0;
    // ==============================
    // 构造方法
    // ==============================

    /**
     * 创造起子构造函数
     * <p>
     * 创建一个创造起子实例，设置物品属性。
     * 创造起子具有较高的耐久度。
     * </p>
     */
    public CreativeScrewdriverItem() {
        super(
                DEFAULT_CAPACITY,
                DEFAULT_TRANSFER,
                DEFAULT_TRANSFER,
                new Item.Properties().stacksTo(1).defaultDurability(1561),
                "timetale_re.tier.level.creative"
        );
    }

    @Override
    public int getMaxModules() {
        return Integer.MAX_VALUE; // 创造等级起子拥有无限槽位
    }

    /**
     * 根据物品堆栈创建模块容器
     * <p>
     * 根据物品堆栈中的等级信息创建相应大小的模块容器
     * </p>
     *
     * @param stack 物品堆栈
     * @return 模块容器
     */
    @Override
    public ToolModuleContainer createModuleContainer(ItemStack stack) {
        return new ToolModuleContainer(getMaxModules());
    }

    /**
     * 获取当前存储的能量
     * <p>
     * 创造起子始终显示为满电状态
     * </p>
     *
     * @param stack 电池物品堆
     * @return 当前存储的能量（始终为最大容量）
     */
    @Override
    public int getEnergyStored(ItemStack stack) {
        return capacity; // 创造起子始终满电
    }

    /**
     * 创建创造等级起子（拥有所有最高级模块，无法添加或移除模块）
     *
     * @return 创造等级起子物品堆栈
     */
    public static ItemStack createCreativeScrewdriver() {
        ItemStack stack = new ItemStack(ItemsRegister.CREATIVE_SCREWDRIVER.get());

        // 添加所有最高级模块
        addHighestLevelModules(stack);

        // 确保能量为满电状态
        if (!stack.hasTag()) {
            stack.setTag(new CompoundTag());
        }
        if (stack.getTag() != null) {
            stack.getTag().putInt("Energy", Integer.MAX_VALUE);
        }

        return stack;
    }

    /**
     * 添加所有最高级模块
     * <p>
     * 为创造等级起子添加每种模块类型的最高级模块
     * </p>
     *
     * @param stack 起子物品堆栈
     */
    private static void addHighestLevelModules(ItemStack stack) {
        ToolModuleContainer container = new ToolModuleContainer(Integer.MAX_VALUE);

        // 自动添加每种模块类型的最高级模块
        Map<ModuleType, IModule> highestLevelModules = Modules.getHighestLevelModulesByType();
        for (IModule module : highestLevelModules.values()) {
            container.addModule(module);
        }

        // 保存模块到起子
        container.saveToItemStack(stack);
    }
    
    /**
     * 添加模块提示信息
     * <p>
     * 当玩家按住Shift键时显示已安装的模块信息
     * </p>
     *
     * @param stack   物品栈
     * @param level   世界对象
     * @param tooltip 提示文本列表
     * @param flag    提示标志
     */
    public void addModuleTooltip(@NotNull ItemStack stack, @Nullable Level level, @NotNull List<Component> tooltip, @NotNull TooltipFlag flag) {
        // 与现有的按Shift显示功能整合
        if (Screen.hasShiftDown()) {
            ToolModuleContainer container = createModuleContainer(stack);
            container.loadFromItemStack(stack);
            displayInstalledModules(container, tooltip);
        }
    }

    /**
     * 右键方块时切换水晶方块的等级
     * <p>
     * 当使用创造起子右键点击水晶方块时，循环切换其等级（1-3级）
     * </p>
     *
     * @param context 使用上下文
     * @return 交互结果
     */
    @Override
    public @NotNull InteractionResult useOn(@NotNull UseOnContext context) {
        Level level = context.getLevel();
        BlockPos blockPos = context.getClickedPos();
        BlockState blockState = level.getBlockState(blockPos);
        Block block = blockState.getBlock();

        // 检查是否为水晶方块
        if (block instanceof CrystalBaseBlock) {
            // 只在服务端执行方块更新逻辑
            if (!level.isClientSide) {
                // 获取当前等级
                IntegerProperty levelProperty = ((CrystalBaseBlock) block).getLevelProperty();
                int currentLevel = blockState.getValue(levelProperty);
                
                // 计算下一个等级（循环：min->max->min）
                int nextLevel = currentLevel + 1;
                
                // 获取最大和最小等级值
                java.util.Optional<Integer> maxLevelOpt = levelProperty.getPossibleValues().stream().max(Integer::compareTo);
                java.util.Optional<Integer> minLevelOpt = levelProperty.getPossibleValues().stream().min(Integer::compareTo);
                
                // 如果获取到最大值且当前等级超过了最大值，则重置为最小值
                if (maxLevelOpt.isPresent() && nextLevel > maxLevelOpt.get()) {
                    nextLevel = minLevelOpt.orElse(1); // 如果无法获取最小值，则默认为1
                } else if (maxLevelOpt.isEmpty()) {
                    nextLevel = currentLevel;
                }
                
                // 更新方块状态
                BlockState newState = blockState.setValue(levelProperty, nextLevel);
                level.setBlock(blockPos, newState, 3);
            }
            
            return InteractionResult.SUCCESS;
        }
        
        // 如果不是水晶方块，则使用父类的逻辑
        return super.useOn(context);
    }
}